home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_descrtut.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  13KB  |  127 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. from test.test_support import sortdict
  5. import pprint
  6.  
  7. class defaultdict(dict):
  8.     
  9.     def __init__(self, default = None):
  10.         dict.__init__(self)
  11.         self.default = default
  12.  
  13.     
  14.     def __getitem__(self, key):
  15.         
  16.         try:
  17.             return dict.__getitem__(self, key)
  18.         except KeyError:
  19.             return self.default
  20.  
  21.  
  22.     
  23.     def get(self, key, *args):
  24.         if not args:
  25.             args = (self.default,)
  26.         
  27.         return dict.get(self, key, *args)
  28.  
  29.     
  30.     def merge(self, other):
  31.         for key in other:
  32.             if key not in self:
  33.                 self[key] = other[key]
  34.                 continue
  35.         
  36.  
  37.  
  38. test_1 = '\n\nHere\'s the new type at work:\n\n    >>> print defaultdict               # show our type\n    <class \'test.test_descrtut.defaultdict\'>\n    >>> print type(defaultdict)         # its metatype\n    <type \'type\'>\n    >>> a = defaultdict(default=0.0)    # create an instance\n    >>> print a                         # show the instance\n    {}\n    >>> print type(a)                   # show its type\n    <class \'test.test_descrtut.defaultdict\'>\n    >>> print a.__class__               # show its class\n    <class \'test.test_descrtut.defaultdict\'>\n    >>> print type(a) is a.__class__    # its type is its class\n    True\n    >>> a[1] = 3.25                     # modify the instance\n    >>> print a                         # show the new value\n    {1: 3.25}\n    >>> print a[1]                      # show the new item\n    3.25\n    >>> print a[0]                      # a non-existant item\n    0.0\n    >>> a.merge({1:100, 2:200})         # use a dict method\n    >>> print sortdict(a)               # show the result\n    {1: 3.25, 2: 200}\n    >>>\n\nWe can also use the new type in contexts where classic only allows "real"\ndictionaries, such as the locals/globals dictionaries for the exec\nstatement or the built-in function eval():\n\n    >>> def sorted(seq):\n    ...     seq.sort()\n    ...     return seq\n    >>> print sorted(a.keys())\n    [1, 2]\n    >>> exec "x = 3; print x" in a\n    3\n    >>> print sorted(a.keys())\n    [1, 2, \'__builtins__\', \'x\']\n    >>> print a[\'x\']\n    3\n    >>>\n\nNow I\'ll show that defaultdict instances have dynamic instance variables,\njust like classic classes:\n\n    >>> a.default = -1\n    >>> print a["noway"]\n    -1\n    >>> a.default = -1000\n    >>> print a["noway"]\n    -1000\n    >>> \'default\' in dir(a)\n    True\n    >>> a.x1 = 100\n    >>> a.x2 = 200\n    >>> print a.x1\n    100\n    >>> d = dir(a)\n    >>> \'default\' in d and \'x1\' in d and \'x2\' in d\n    True\n    >>> print sortdict(a.__dict__)\n    {\'default\': -1000, \'x1\': 100, \'x2\': 200}\n    >>>\n'
  39.  
  40. class defaultdict2(dict):
  41.     __slots__ = [
  42.         'default']
  43.     
  44.     def __init__(self, default = None):
  45.         dict.__init__(self)
  46.         self.default = default
  47.  
  48.     
  49.     def __getitem__(self, key):
  50.         
  51.         try:
  52.             return dict.__getitem__(self, key)
  53.         except KeyError:
  54.             return self.default
  55.  
  56.  
  57.     
  58.     def get(self, key, *args):
  59.         if not args:
  60.             args = (self.default,)
  61.         
  62.         return dict.get(self, key, *args)
  63.  
  64.     
  65.     def merge(self, other):
  66.         for key in other:
  67.             if key not in self:
  68.                 self[key] = other[key]
  69.                 continue
  70.         
  71.  
  72.  
  73. test_2 = '\n\nThe __slots__ declaration takes a list of instance variables, and reserves\nspace for exactly these in the instance. When __slots__ is used, other\ninstance variables cannot be assigned to:\n\n    >>> a = defaultdict2(default=0.0)\n    >>> a[1]\n    0.0\n    >>> a.default = -1\n    >>> a[1]\n    -1\n    >>> a.x1 = 1\n    Traceback (most recent call last):\n      File "<stdin>", line 1, in ?\n    AttributeError: \'defaultdict2\' object has no attribute \'x1\'\n    >>>\n\n'
  74. test_3 = '\n\nIntrospecting instances of built-in types\n\nFor instance of built-in types, x.__class__ is now the same as type(x):\n\n    >>> type([])\n    <type \'list\'>\n    >>> [].__class__\n    <type \'list\'>\n    >>> list\n    <type \'list\'>\n    >>> isinstance([], list)\n    True\n    >>> isinstance([], dict)\n    False\n    >>> isinstance([], object)\n    True\n    >>>\n\nUnder the new proposal, the __methods__ attribute no longer exists:\n\n    >>> [].__methods__\n    Traceback (most recent call last):\n      File "<stdin>", line 1, in ?\n    AttributeError: \'list\' object has no attribute \'__methods__\'\n    >>>\n\nInstead, you can get the same information from the list type:\n\n    >>> pprint.pprint(dir(list))    # like list.__dict__.keys(), but sorted\n    [\'__add__\',\n     \'__class__\',\n     \'__contains__\',\n     \'__delattr__\',\n     \'__delitem__\',\n     \'__delslice__\',\n     \'__doc__\',\n     \'__eq__\',\n     \'__ge__\',\n     \'__getattribute__\',\n     \'__getitem__\',\n     \'__getslice__\',\n     \'__gt__\',\n     \'__hash__\',\n     \'__iadd__\',\n     \'__imul__\',\n     \'__init__\',\n     \'__iter__\',\n     \'__le__\',\n     \'__len__\',\n     \'__lt__\',\n     \'__mul__\',\n     \'__ne__\',\n     \'__new__\',\n     \'__reduce__\',\n     \'__reduce_ex__\',\n     \'__repr__\',\n     \'__reversed__\',\n     \'__rmul__\',\n     \'__setattr__\',\n     \'__setitem__\',\n     \'__setslice__\',\n     \'__str__\',\n     \'append\',\n     \'count\',\n     \'extend\',\n     \'index\',\n     \'insert\',\n     \'pop\',\n     \'remove\',\n     \'reverse\',\n     \'sort\']\n\nThe new introspection API gives more information than the old one:  in\naddition to the regular methods, it also shows the methods that are\nnormally invoked through special notations, e.g. __iadd__ (+=), __len__\n(len), __ne__ (!=). You can invoke any method from this list directly:\n\n    >>> a = [\'tic\', \'tac\']\n    >>> list.__len__(a)          # same as len(a)\n    2\n    >>> a.__len__()              # ditto\n    2\n    >>> list.append(a, \'toe\')    # same as a.append(\'toe\')\n    >>> a\n    [\'tic\', \'tac\', \'toe\']\n    >>>\n\nThis is just like it is for user-defined classes.\n'
  75. test_4 = '\n\nStatic methods and class methods\n\nThe new introspection API makes it possible to add static methods and class\nmethods. Static methods are easy to describe: they behave pretty much like\nstatic methods in C++ or Java. Here\'s an example:\n\n    >>> class C:\n    ...\n    ...     def foo(x, y):\n    ...         print "staticmethod", x, y\n    ...     foo = staticmethod(foo)\n\n    >>> C.foo(1, 2)\n    staticmethod 1 2\n    >>> c = C()\n    >>> c.foo(1, 2)\n    staticmethod 1 2\n\nClass methods use a similar pattern to declare methods that receive an\nimplicit first argument that is the *class* for which they are invoked.\n\n    >>> class C:\n    ...     def foo(cls, y):\n    ...         print "classmethod", cls, y\n    ...     foo = classmethod(foo)\n\n    >>> C.foo(1)\n    classmethod test.test_descrtut.C 1\n    >>> c = C()\n    >>> c.foo(1)\n    classmethod test.test_descrtut.C 1\n\n    >>> class D(C):\n    ...     pass\n\n    >>> D.foo(1)\n    classmethod test.test_descrtut.D 1\n    >>> d = D()\n    >>> d.foo(1)\n    classmethod test.test_descrtut.D 1\n\nThis prints "classmethod __main__.D 1" both times; in other words, the\nclass passed as the first argument of foo() is the class involved in the\ncall, not the class involved in the definition of foo().\n\nBut notice this:\n\n    >>> class E(C):\n    ...     def foo(cls, y): # override C.foo\n    ...         print "E.foo() called"\n    ...         C.foo(y)\n    ...     foo = classmethod(foo)\n\n    >>> E.foo(1)\n    E.foo() called\n    classmethod test.test_descrtut.C 1\n    >>> e = E()\n    >>> e.foo(1)\n    E.foo() called\n    classmethod test.test_descrtut.C 1\n\nIn this example, the call to C.foo() from E.foo() will see class C as its\nfirst argument, not class E. This is to be expected, since the call\nspecifies the class C. But it stresses the difference between these class\nmethods and methods defined in metaclasses (where an upcall to a metamethod\nwould pass the target class as an explicit first argument).\n'
  76. test_5 = '\n\nAttributes defined by get/set methods\n\n\n    >>> class property(object):\n    ...\n    ...     def __init__(self, get, set=None):\n    ...         self.__get = get\n    ...         self.__set = set\n    ...\n    ...     def __get__(self, inst, type=None):\n    ...         return self.__get(inst)\n    ...\n    ...     def __set__(self, inst, value):\n    ...         if self.__set is None:\n    ...             raise AttributeError, "this attribute is read-only"\n    ...         return self.__set(inst, value)\n\nNow let\'s define a class with an attribute x defined by a pair of methods,\ngetx() and and setx():\n\n    >>> class C(object):\n    ...\n    ...     def __init__(self):\n    ...         self.__x = 0\n    ...\n    ...     def getx(self):\n    ...         return self.__x\n    ...\n    ...     def setx(self, x):\n    ...         if x < 0: x = 0\n    ...         self.__x = x\n    ...\n    ...     x = property(getx, setx)\n\nHere\'s a small demonstration:\n\n    >>> a = C()\n    >>> a.x = 10\n    >>> print a.x\n    10\n    >>> a.x = -10\n    >>> print a.x\n    0\n    >>>\n\nHmm -- property is builtin now, so let\'s try it that way too.\n\n    >>> del property  # unmask the builtin\n    >>> property\n    <type \'property\'>\n\n    >>> class C(object):\n    ...     def __init__(self):\n    ...         self.__x = 0\n    ...     def getx(self):\n    ...         return self.__x\n    ...     def setx(self, x):\n    ...         if x < 0: x = 0\n    ...         self.__x = x\n    ...     x = property(getx, setx)\n\n\n    >>> a = C()\n    >>> a.x = 10\n    >>> print a.x\n    10\n    >>> a.x = -10\n    >>> print a.x\n    0\n    >>>\n'
  77. test_6 = '\n\nMethod resolution order\n\nThis example is implicit in the writeup.\n\n>>> class A:    # classic class\n...     def save(self):\n...         print "called A.save()"\n>>> class B(A):\n...     pass\n>>> class C(A):\n...     def save(self):\n...         print "called C.save()"\n>>> class D(B, C):\n...     pass\n\n>>> D().save()\ncalled A.save()\n\n>>> class A(object):  # new class\n...     def save(self):\n...         print "called A.save()"\n>>> class B(A):\n...     pass\n>>> class C(A):\n...     def save(self):\n...         print "called C.save()"\n>>> class D(B, C):\n...     pass\n\n>>> D().save()\ncalled C.save()\n'
  78.  
  79. class A(object):
  80.     
  81.     def m(self):
  82.         return 'A'
  83.  
  84.  
  85.  
  86. class B(A):
  87.     
  88.     def m(self):
  89.         return 'B' + super(B, self).m()
  90.  
  91.  
  92.  
  93. class C(A):
  94.     
  95.     def m(self):
  96.         return 'C' + super(C, self).m()
  97.  
  98.  
  99.  
  100. class D(C, B):
  101.     
  102.     def m(self):
  103.         return 'D' + super(D, self).m()
  104.  
  105.  
  106. test_7 = '\n\nCooperative methods and "super"\n\n>>> print D().m() # "DCBA"\nDCBA\n'
  107. test_8 = '\n\nBackwards incompatibilities\n\n>>> class A:\n...     def foo(self):\n...         print "called A.foo()"\n\n>>> class B(A):\n...     pass\n\n>>> class C(A):\n...     def foo(self):\n...         B.foo(self)\n\n>>> C().foo()\nTraceback (most recent call last):\n ...\nTypeError: unbound method foo() must be called with B instance as first argument (got C instance instead)\n\n>>> class C(A):\n...     def foo(self):\n...         A.foo(self)\n>>> C().foo()\ncalled A.foo()\n'
  108. __test__ = {
  109.     'tut1': test_1,
  110.     'tut2': test_2,
  111.     'tut3': test_3,
  112.     'tut4': test_4,
  113.     'tut5': test_5,
  114.     'tut6': test_6,
  115.     'tut7': test_7,
  116.     'tut8': test_8 }
  117.  
  118. def test_main(verbose = None):
  119.     test_support = test_support
  120.     test_descrtut = test_descrtut
  121.     import test
  122.     test_support.run_doctest(test_descrtut, verbose)
  123.  
  124. if __name__ == '__main__':
  125.     test_main(1)
  126.  
  127.